package com.zrrd.learn.chapter06数组;

import java.util.Arrays;

/**
 * 定长数组 ： 长度固定的
 * 1 : {1,1,2,1,1,3,3,4,5,34,23,6,4,7,45,34,23,45,67,8,45,67}
 * 1.1求这个数组中所有2的倍数  int[]
 * <p>
 * <p>
 * 动态数组 ：可变长数组，数组
 * <p>
 * 封装成一个类  DynanicArray
 * <p>
 * 底层 ： 数组
 * 初始长度 ：10
 * 扩容
 * 最大长度 ：
 * <p>
 * 面向对象：    50%  结果
 * <p>
 * 函数式编程：  50% function abc(){}
 * <p>
 * 面向过程：   100% 细节
 * <p>
 * <p>
 * 数据结构:    线性存储结构 [数组 | 动态数组{自写}]
 *
 * @author wrn
 * @version 1.0
 * @date 2023/7/13 8:16
 */

public class DynamicArray {

    int init_capacity = 10;

    int max_capacity = Integer.MAX_VALUE;

    int[] bottom_array;


    /**
     * 索引 ： 用来存储数组元素时的下标
     */
    int index = 0;

    /**
     * 成员方法
     * 构造方法 ： 与类名相同的方法，不能有返回值，什么时候执行 当有人new时
     */
    public DynamicArray() {
        bottom_array = new int[init_capacity];
    }

    /**
     * 用来完成把obj放到数组bottoma_array里面的操作
     *
     * @param obj 使用者给我的数据
     * @return
     */
    public boolean add(int obj) {
        bottom_array[index++] = obj;
        return true;
    }

    /**
     * 计算底层数组最后的扩展长度
     */

    public void computeNewLength() {

        int newCapacity = bottom_array.length + (bottom_array.length >> 1);
        int lastCapacity = newCapacity > max_capacity ? max_capacity : (int) newCapacity;

        if (index == bottom_array.length) {
            bottom_array = Arrays.copyOf(bottom_array, lastCapacity);

        }
    }

    /**
     * 表示当前动态数组里面有多少个整数
     *
     * @return
     */
    public int size() {
        return index;
    }

    /**
     * 通过下标来获取元素内容
     *
     * @param index 下标
     * @return
     */
    public int get(int index) {
        return bottom_array[index];
    }

    public boolean delete(int start) {

        if (start >= index) {
            return false;
        }
        if (start == index - 1) {
            index--;
            return true;
        }

        for (int i = 0; i < bottom_array.length - 1; i++) {
            bottom_array[i] = bottom_array[i + 1];
        }

        index--;
        return true;

        //后一位元素向前移动
        //如果删除的是最后一个元素，那么直接index--

        //不是最后一个
        //1 向前移动
        //2 产生新的数组
        //3 index--
        //return true;
    }


    public static void main(String[] args) {

        DynamicArray dd =new DynamicArray();

        dd.add(1);
        dd.add(1);
        dd.add(1);
        dd.add(1);

        dd.delete(0);
        for (int i = 0; i < dd.size(); i++) {
            System.out.println(dd.get(i));
        }

        int[] as = {1, 1, 2, 1, 1, 3, 3, 4, 5, 34, 23, 6, 4, 7, 45, 34, 23, 45, 67, 8, 45, 67, 24};
        DynamicArray d = new DynamicArray();
        for (int i = 0; i < as.length; i++) {
            if (as[i] % 2 == 0) {
                d.add(as[i]);
            }
        }
        System.out.println(d.get(7));
        System.out.println(d.index);

        //引用类型
//        DynamicArray d = new DynamicArray();
//
//        System.out.println(d.size());
//        System.out.println(d.bottom_array.length);
//        for (int i = 0; i < 100; i++) {
//            d.add(i + 1);
//        }
//
//        System.out.println(d.size());
//        System.out.println(d.bottom_array.length);
    }


}
